In the past, computer programs were typically written for specific computer platforms. For example, a program designed to operate on a Unix-based computer has its code written in accordance with the instruction set that is appropriate for that type of computer. When the program is to be run on the computer, it could be executed in one of two ways, namely compiled or interpreted, depending upon the particular language in which the program is written. For languages which employ compilers, such as C and C++, the compiling operation transforms the original source program into executable code that can be run on a specific computer architecture. The entire program is transformed, or compiled, prior to the time that any execution of the program takes place. In other words, the compiled program is in a state which enables each instruction to be readily executed at run time by the particular computer for which it has been compiled.
Other types of programming languages, such as BASIC, do not require the source program to be compiled prior to execution. Rather, programs written in these types of languages are interpreted during run time. In this type of operation, as each instruction is decoded, one of a number of possible actions is performed immediately, by a program known as an interpreter. Although interpreted programs take longer to run than compiled programs, due to the fact that the instructions must be individually decoded and executed during run time, they offer the advantage that they can be platform-independent. More particularly, an interpreted program can be delivered to, and installed upon, a number of different computer systems in its original, source language. Each computer system can have its own interpreter, for converting the source code into executable machine code appropriate for that computer. Thus, each of the different computers can run the same program, even if they operate on different platforms. In contrast, however, once a program has been compiled, it can only be run on the computer platform for which it was compiled.
For this reason, as the use of computers continues to increase, and the desirability of sharing and distributing computer programs among multiple different types of computers also increases, interpreted computer languages have been gaining increasing popularity. One particular example of this phenomenon can be seen in the expanding use of the internet, via which millions of different computers can interact with one another. The individual users employ a variety of different types of computers, which have different operating platforms. In an environment such as this, it is not feasible to develop a program which can run on only one of these platforms. In such a case, the program would not be able to be shared by all of the various users. Conversely, it is not practical to write multiple versions of the same program for each of the different platforms. For this reason, therefore, platform-independent types of programming languages are utilized. To permit them to be platform independent, these languages employ an intermediate form of representation, known as interpreted bytecode. In general, original source code is first compiled into the bytecode representation. This bytecode representation is independent of any specific computer platform. When it is run on a particular computer, the code is executed by an interpreter that is specific to the computer. In essence, the interpreter reads the bytecodes and executes the appropriate operation indicated by each one. In this manner, a single program can be shared among users of a variety of different types of computers, all having different operating platforms.
There may be situations in which it is desirable to access functions in a computer which lie outside of the interpreted bytecode program. For example, the native operating system of a computer is typically in a compiled form. The operating system may offer various types of services and functions that can be utilized by an interpreted bytecode program that is downloaded over a network. For example, it may be desirable to access functions that are contained in a shared library, such as a dynamically linked library.
In the past, such an operation was accomplished by designing a custom type of interface, sometimes known as "glue code", for each native function to be called from the interpreted program. Since special code had to be written for every desirable native function, such an approach required a significant amount of work and did not offer much flexibility for adapting to new native functions.
It is one object of the present invention, therefore, to provide a procedure by which an interpreted bytecode program can directly access functions which reside outside of that program, such as those provided by the native compiled operating system of the computer, without having to use intermediate glue code. Such an objective is particularly desirable for functions which are provided by shared libraries that are dynamically linked during the run time of the computer.
Further along these lines, many programs are being written with the use of object-oriented programming languages. In a pure object-oriented language, functions do not exist by themselves. Rather, all operations take place within objects, that are defined by classes. Thus, in a pure object-oriented program, every function belongs to a particular class. A function, or method as it is often termed, is invoked upon an instance of the class, or in the case of class methods, on the class itself.
In some situations, it may be desirable to employ services outside of those explicitly provided by an object-oriented program. However, in order for the program to employ those services, they must reside in a recognized class of objects. Hence, it is another objective of the present invention to provide a mechanism via which functions in a non-object-oriented environment, which lie outside of recognized classes, can be utilized by an object-oriented program, and vice versa.